package fr.univ.colloque.dao;

import fr.univ.colloque.data.MotCle;
import fr.univ.colloque.util.PoolConnexion;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

public class MotCleDao
{

    /**
     * Retourne la liste de tous les mot clé
     *
     * @return liste de tous les mot clés
     */
    public List<MotCle> getAll()
    {
        PoolConnexion pool = PoolConnexion.getInstance();

        String requete = "select * from MOTCLE";
        PreparedStatement pStat = null;

        Connection con = null;
        ResultSet rs = null;

        List<MotCle> listMc = new ArrayList<MotCle>();

        try
        {
            con = pool.getConnexion();
            pStat = con.prepareStatement(requete);
            rs = pStat.executeQuery();

            while (rs.next())
            {
                int id = rs.getInt("id_motCle");
                String libelle = rs.getString("libelle_motCle");

                MotCle mc = new MotCle();
                mc.setId(id);
                mc.setLibelle(libelle);

                listMc.add(mc);
            }

        }
        catch (SQLException ex)
        {
            Logger.getLogger(PersonneDao.class.getName()).log(Level.SEVERE, null, ex);
        }
        finally
        {
            pool.fermerConnexion(rs, pStat, con);
        }

        return listMc;
    }

    /**
     * Retourne le mot clé correspondant à l'identifiant passé en paramètre
     *
     * @param id identifiant du mot clé souhaité
     * @return mot clé souhaité ou null si non trouvé
     */
    public MotCle get(int id)
    {
        PoolConnexion pool = PoolConnexion.getInstance();

        String requete = "select * from MOTCLE where id_motCle=?";
        PreparedStatement pStat = null;

        Connection con = null;
        ResultSet rs = null;

        MotCle mc = null;

        try
        {
            con = pool.getConnexion();
            pStat = con.prepareStatement(requete);
            pStat.setInt(1, id);
            rs = pStat.executeQuery();

            if (rs.next())
            {
                String libelle = rs.getString("libelle_motCle");

                mc = new MotCle();
                mc.setId(id);
                mc.setLibelle(libelle);
            }

        }
        catch (SQLException ex)
        {
            Logger.getLogger(PersonneDao.class.getName()).log(Level.SEVERE, null, ex);
        }
        finally
        {
            pool.fermerConnexion(rs, pStat, con);
        }

        return mc;
    }

    /**
     * Sauvegarde les mots clés d'un colloque
     *
     * @param idColloque identifiant du colloque
     * @param lstMotCle liste des mots clés à enregistrer
     */
    public void saveMcDuColloque(int idColloque, List<MotCle> lstMotCle)
    {
        PoolConnexion pool = PoolConnexion.getInstance();

        String requete = "insert into UTILISER (id_motCle, id_colloc) values (?,?)";
        PreparedStatement pStat = null;

        Connection con = null;

        try
        {
            con = pool.getConnexion();
            pStat = con.prepareStatement(requete);

            for (MotCle mc : lstMotCle)
            {
                pStat.setInt(1, mc.getId());
                pStat.setInt(2, idColloque);
                pStat.executeUpdate();
            }
        }
        catch (SQLException ex)
        {
            Logger.getLogger(PersonneDao.class.getName()).log(Level.SEVERE, null, ex);
        }
        finally
        {
            pool.fermerConnexion(null, pStat, con);
        }

    }

    /**
     * Enregistre les mots clés pour un exposé
     *
     * @param idExpose identifiant de l'exposé
     * @param lstMotCle liste des mots clés à enregistrer
     */
    public void saveMcExpose(int idExpose, List<MotCle> lstMotCle)
    {
        PoolConnexion pool = PoolConnexion.getInstance();

        String requete = "insert into DECRIRE (id_motCle, id_exp) values (?,?)";
        PreparedStatement pStat = null;

        Connection con = null;

        try
        {
            con = pool.getConnexion();
            pStat = con.prepareStatement(requete);

            for (MotCle mc : lstMotCle)
            {
                pStat.setInt(1, mc.getId());
                pStat.setInt(2, idExpose);
                pStat.executeUpdate();
            }
        }
        catch (SQLException ex)
        {
            Logger.getLogger(PersonneDao.class.getName()).log(Level.SEVERE, null, ex);
        }
        finally
        {
            pool.fermerConnexion(null, pStat, con);
        }

    }

    /**
     * Retourne la liste des mot clés correspondant à l'id du colloque passé en
     * parametre
     *
     * @param idCo identifiant du colloque
     * @return
     */
    public List<MotCle> getColloqueMc(int idCo)
    {
        PoolConnexion pool = PoolConnexion.getInstance();

        String requete = "select * from UTILISER where id_colloc=?";
        PreparedStatement pStat = null;

        Connection con = null;
        ResultSet rs = null;

        List<MotCle> listMcColloque = new ArrayList<MotCle>();

        try
        {
            con = pool.getConnexion();
            pStat = con.prepareStatement(requete);
            pStat.setInt(1, idCo);
            rs = pStat.executeQuery();

            while (rs.next())
            {
                int id = rs.getInt("id_motCle");

                MotCle mc;
                mc = this.get(id);
                listMcColloque.add(mc);
            }

        }
        catch (SQLException ex)
        {
            Logger.getLogger(PersonneDao.class.getName()).log(Level.SEVERE, null, ex);
        }
        finally
        {
            pool.fermerConnexion(rs, pStat, con);
        }

        return listMcColloque;
    }

    /**
     * Retourne les mots clés caractérisant une personne
     *
     * @param idPersonne identifiant de la personne
     * @return
     */
    public List<MotCle> getPersonneMc(int idPersonne)
    {
        PoolConnexion pool = PoolConnexion.getInstance();

        String requete = "select * from CARACTERISER where id_pers=?";
        PreparedStatement pStat = null;

        Connection con = null;
        ResultSet rs = null;

        List<MotCle> listMcColloque = new ArrayList<MotCle>();

        try
        {
            con = pool.getConnexion();
            pStat = con.prepareStatement(requete);
            pStat.setInt(1, idPersonne);
            rs = pStat.executeQuery();

            while (rs.next())
            {
                int id = rs.getInt("id_motCle");

                MotCle mc;
                mc = this.get(id);
                listMcColloque.add(mc);
            }

        }
        catch (SQLException ex)
        {
            Logger.getLogger(PersonneDao.class.getName()).log(Level.SEVERE, null, ex);
        }
        finally
        {
            pool.fermerConnexion(rs, pStat, con);
        }

        return listMcColloque;
    }

    /**
     * Récupère la liste des mots clés d'un exposé
     *
     * @param idExp identifiant de l'exposé
     * @return
     */
    public List<MotCle> getExposeMc(int idExp)
    {
        PoolConnexion pool = PoolConnexion.getInstance();

        String requete = "select * from DECRIRE where id_exp=?";
        PreparedStatement pStat = null;

        Connection con = null;
        ResultSet rs = null;

        List<MotCle> listMcExp = new ArrayList<MotCle>();

        try
        {
            con = pool.getConnexion();
            pStat = con.prepareStatement(requete);
            pStat.setInt(1, idExp);
            rs = pStat.executeQuery();

            while (rs.next())
            {
                int id = rs.getInt("id_motCle");

                MotCle mc;
                mc = this.get(id);
                listMcExp.add(mc);
            }

        }
        catch (SQLException ex)
        {
            Logger.getLogger(PersonneDao.class.getName()).log(Level.SEVERE, null, ex);
        }
        finally
        {
            pool.fermerConnexion(rs, pStat, con);
        }

        return listMcExp;
    }
}